In AI/libs/core/pipeline.py around lines 54 to 56, end_date is hard-coded to
2024-10-30 which excludes all post-2024-10-30 data; restore dynamic calculation
by replacing the fixed date with the current UTC date (e.g., call _utcnow() or
datetime.utcnow()) so end_date reflects "today" and then compute start_date as
end_date - timedelta(days=600); ensure you use the same timezone/UTC helper used
elsewhere (_utcnow()) to keep consistency.

#!/bin/bash
# GitHub CLI를 사용하여 이슈 생성
gh issue create \
  --repo SISC-IT/sisc-web \
  --title "파이프라인 end_date 하드코딩 제거 필요" \
  --body "## 설명
AI/libs/core/pipeline.py의 run_signal_transformer 함수에서 end_date가 2024-10-30으로 고정되어 있어, 최신 데이터가 조회되지 않는 문제가 있습니다.

## 위치
- 파일: AI/libs/core/pipeline.py
- 라인: 54-56

## 현재 코드
\`\`\`python
#end_date = _utcnow() # 한국 시간 기준 당일 종가까지 사용, 서버 사용시 주석 해제
end_date = datetime.strptime(\"2024-10-30\", \"%Y-%m-%d\") #임시 고정 날짜
\`\`\`

## 필요한 작업
현재 UTC 날짜를 기준으로 동적으로 계산하도록 변경이 필요합니다.

## 참조
- PR: https://github.com/SISC-IT/sisc-web/pull/80
- 리뷰 코멘트: https://github.com/SISC-IT/sisc-web/pull/80#discussion_r2493423198
- 요청자: @twq110" \
  --assignee twq110

def run_xai(decision: Dict[str, Any], api_key: str) -> str:

    evidence = decision.pop("evidence", [])
    report = generate_report_from_yf(decision, evidence, api_key)
    return report

def get_db_conn(db_name: str):
    """
    - psycopg2 로우 커넥션 생성(직접 커서 열어 사용할 때)
    - pandas 경고가 싫다면 read_sql에는 get_engine() 사용을 권장
    """
    cfg = _get_db_config(db_name)
    return psycopg2.connect(
        host=cfg["host"],
        user=cfg["user"],
        password=cfg["password"],
        dbname=cfg["dbname"],
        port=int(cfg.get("port", 5432)),
        sslmode=cfg.get("sslmode", None),  # 필요 시 자동 적용
    )

def save_reports_to_db(rows: List[ReportRow], db_name: str) -> int:
    """
    한국어 주석:
    - SQLAlchemy로 안전하게 INSERT.
    - pandas 경고 제거, 커넥션 관리 자동화, 프리핑으로 죽은 커넥션 방지.
    """
    if not rows:
        print("[INFO] 저장할 리포트가 없습니다.")
        return 0

    engine = get_engine(db_name)
    ensure_table_schema(engine)

    created_at = utcnow()
    params = build_insert_params(rows, created_at)
    if not params:
        print("[WARN] 유효한 저장 파라미터가 없어 INSERT를 건너뜁니다.")
        return 0

    insert_sql = text("""
        INSERT INTO public.xai_reports (ticker, signal, price, date, report, created_at)
        VALUES (:ticker, :signal, :price, :date, :report, :created_at)
    """)

    inserted = 0
    # 대량이면 청크 분할 권장
    CHUNK = 1000
    with engine.begin() as conn:
        for i in range(0, len(params), CHUNK):
            batch = params[i:i+CHUNK]
            conn.execute(insert_sql, batch)
            inserted += len(batch)

    print(f"--- {inserted}개의 XAI 리포트가 데이터베이스에 저장되었습니다. ---")
    return inserted

def run_finder():
    """
    전체 프로세스를 조율하여 최종 Top 3 투자 종목 반환
    """
    # --- 1단계: 의존성 객체 및 데이터 준비 ---
    try:
        llm = get_ollama_client()  # ✅ 헬스체크 및 모델 확인 포함
    except Exception as e:
        print(str(e))
        return []

    csv_path = os.path.join(project_root, "data", "stability_score_2025.csv")

    try:
        stability_df = pd.read_csv(csv_path)
    except FileNotFoundError:
        print(f"오류: {csv_path} 파일을 찾을 수 없습니다.")
        return []

    # --- 2단계: 주간 뉴스 데이터 수집 및 요약 ---
    try:
        weekly_news_df = news_processing.get_weekly_news_summary(days=5, llm_client=llm)
    except requests.exceptions.ConnectionError as e:
        print(f"[LLM 연결 오류] 뉴스 요약 단계에서 LLM 서버 연결 실패: {e}")
        return []
    except requests.exceptions.Timeout as e:
        print(f"[LLM 타임아웃] 뉴스 요약 단계에서 응답 지연: {e}")
        return []
    except Exception as e:
        print(f"[예기치 못한 오류] 뉴스 요약 단계: {e}")
        return []

    if weekly_news_df is None or getattr(weekly_news_df, "empty", False):
        print("분석할 뉴스 데이터가 없어 프로세스를 종료합니다.")
        return []

    # --- 3단계: 뉴스 데이터와 재무 데이터를 기반으로 Top 3 종목 선정 ---
    try:
        top_3_tickers = ticker_selector.select_top_stocks(
            news_summary_df=weekly_news_df,
            stability_df=stability_df,
            llm_client=llm
        )
    except requests.exceptions.ConnectionError as e:
        print(f"[LLM 연결 오류] 종목 선정 단계에서 LLM 서버 연결 실패: {e}")
        return []
    except requests.exceptions.Timeout as e:
        print(f"[LLM 타임아웃] 종목 선정 단계에서 응답 지연: {e}")
        return []
    except Exception as e:
        print(f"[예기치 못한 오류] 종목 선정 단계: {e}")
        return []

    print("\n🎉 [Finder 모듈 최종 결과] 투자 추천 Top 3 종목 🎉")
    print(top_3_tickers)
    return top_3_tickers

def fetch_ohlcv(
    ticker: str,
    start: str,
    end: str,
    interval: str = "1d",
    db_name: str = "db",
) -> pd.DataFrame:
    """
    특정 티커, 날짜 범위의 OHLCV 데이터를 DB에서 불러오기 (SQLAlchemy 엔진 사용)

    Args:
        ticker (str): 종목 코드 (예: "AAPL")
        start (str): 시작일자 'YYYY-MM-DD' (inclusive)
        end (str): 종료일자 'YYYY-MM-DD' (inclusive)
        interval (str): 데이터 간격 ('1d' 등) - 현재 테이블이 일봉만 제공하면 무시됨
        db_name (str): get_engine()가 참조할 설정 블록 이름 (예: "db", "report_DB")

    Returns:
        pd.DataFrame: 컬럼 = [ticker, date, open, high, low, close, adjusted_close, volume]
                      (date 컬럼은 pandas datetime으로 변환됨)
    """

    # 1) SQLAlchemy engine 얻기 ( configs/config.json 기준 )
    engine = get_engine(db_name)

    # 2) 쿼리: named parameter(:ticker 등) 사용 -> 안전하고 가독성 좋음
    #    - interval 분기가 필요하면 테이블/파티션 구조에 따라 쿼리를 분기하도록 확장 가능
    query = text("""
        SELECT ticker, date, open, high, low, close, adjusted_close, volume
        FROM public.price_data
        WHERE ticker = :ticker
          AND date BETWEEN :start AND :end
        ORDER BY date;
    """)

    # 3) DB에서 읽기 (with 문으로 커넥션 자동 정리)
    with engine.connect() as conn:
        df = pd.read_sql(
            query,
            con=conn,  # 꼭 키워드 인자로 con=conn
            params={"ticker": ticker, "start": start, "end": end},  # 튜플 X, 딕셔너리 O
            )

    # 4) 후처리: 컬럼 정렬 및 date 타입 통일
    if df is None or df.empty:
        # 빈 DataFrame이면 일관된 컬럼 스키마로 반환
        return pd.DataFrame(columns=["ticker", "date", "open", "high", "low", "close", "adjusted_close", "volume"])

    # date 컬럼을 datetime으로 변경 (UTC로 맞추고 싶으면 pd.to_datetime(..., utc=True) 사용)
    if "date" in df.columns:
        df["date"] = pd.to_datetime(df["date"])

    # 선택: 컬럼 순서 고정 (일관성 유지)
    desired_cols = ["ticker", "date", "open", "high", "low", "close", "adjusted_close", "volume"]
    # 존재하는 컬럼만 가져오기
    cols_present = [c for c in desired_cols if c in df.columns]
    df = df.loc[:, cols_present]

    return df

def run_transformer(
    *,
    finder_df: pd.DataFrame,
    seq_len: int,
    pred_h: int,
    raw_data: pd.DataFrame,
    run_date: Optional[str] = None,
    weights_path: Optional[str] = None,
    interval: str = "1d",
) -> Dict[str, pd.DataFrame]:
    """

    Parameters
    ----------
    finder_df : pd.DataFrame
        ['ticker'] 컬럼 포함. Finder 단계에서 선정된 추론 대상 종목 목록.
    seq_len : int
        모델 입력 시퀀스 길이(예: 64).
    pred_h : int
        예측 지평(예: 5). 라벨링/정책 기준(로그, 가중치 산정 보조)에 쓰이며
        추론 확률 계산 자체에는 직접 관여하지 않음.
    raw_data : pd.DataFrame
        OHLCV 시계열. 필수 컬럼:
        ['ticker','open','high','low','close','volume', ('ts_local' or 'date')]
    run_date : Optional[str]
        'YYYY-MM-DD' 형식. 지정 시, 해당 날짜(포함)까지의 데이터만 사용해 추론.
        미지정 시, Asia/Seoul 기준 당일 종가까지 사용.
    config : Optional[dict]
        config["transformer"]["model_path"] 에 학습된 가중치 경로가 존재해야 함.
        예) {"transformer": {"model_path": "artifacts/transformer_cls.h5"}}
        (추후 추론 방식 옵션이 늘어나면 이 dict 에 플래그/파라미터를 확장하세요.)
    interval : str
        캔들 간격 표기(로그용). 예: '1d', '1h' 등.

    Returns
    -------
    Dict[str, pd.DataFrame]
        {"logs": DataFrame} 형식.
        컬럼: ["ticker","date","action","price","weight",
               "feature1","feature2","feature3","prob1","prob2","prob3"]

    Notes
    -----
    - 이 래퍼는 '이름/시그니처의 안정성' 확보가 목적입니다.
      내부 추론 엔진이 변경되어도 외부 호출부 수정 없이 교체가 가능합니다.
    """

    # 1) weights_path 경로지정
    PROJECT_ROOT = Path(__file__).resolve().parents[1]

    weights_dir = PROJECT_ROOT / "transformer" / "weights"
    candidate = weights_dir / "initial.weights.h5"

    weights_path = str(candidate)
    if candidate.exists():
            
            print(f"[TRANSFORMER] weights_path 설정됨: {weights_path}")

    if not weights_path:
        print("[TRANSFORMER][WARN] weights_path 미설정 → 가중치 없이 랜덤 초기화로 추론될 수 있음(품질 저하).")
        print("  config 예시: {'transformer': {'weights_path': 'weights/initial.weights.h5'}}")


    # 2) 실제 추론 실행(모듈 위임)
    return run_inference(
        finder_df=finder_df,
        raw_data=raw_data,
        seq_len=seq_len,
        pred_h=pred_h,
        weights_path=weights_path,   # ★ 학습 가중치 경로 전달
        run_date=run_date,
        interval=interval,
    )

In AI/libs/utils/save_reports_to_db.py around lines 27 to 45, the ALTER TABLE
will fail if the public.xai_reports table does not exist; before
querying/altering columns run a CREATE TABLE IF NOT EXISTS public.xai_reports
(...) with the minimal required columns and defaults (ticker, signal, price,
date, report, created_at) to ensure the table exists, then re-query
information_schema and only run ALTER TABLE to add any missing columns; keep
these statements inside the same engine.begin() context to preserve atomicity
and avoid raising UndefinedTable.

In AI/transformer/main.py around lines 65 to 72, the code sets weights_path =
str(candidate) unconditionally so the subsequent if not weights_path check never
triggers and there is no handling when the file doesn't exist; change the logic
to first check whether candidate is truthy and candidate.exists(), only then set
weights_path = str(candidate) and print the “[TRANSFORMER] weights_path 설정됨”
message; otherwise set weights_path to None (or empty string) and print the
warning lines about missing weights and example config; ensure you also handle
the case candidate is None or not a Path-like object before calling exists().

In AI/transformer/modules/__init__.py around line 1, the header comment has a
typo ("tranformer" → "transformer") and a leading BOM character; remove the BOM
by saving the file as UTF-8 without BOM and correct the header text to
"AI/transformer/modules/__init__.py" (fix the spelling only in the header
comment), then re-save the file ensuring no BOM remains.